$(function($) {
    /////////////////////////////////////////
    //
    //  产生唯一的linkno，范围1-~
    ////////////////////////////////////////
    var LinkNo = (function() {
        ///////////////////////////////////////
        linkno = [];

        appendEqpId = function(val) {
            linkno.push(val);
            console.dir(linkno);
        }
        //获取唯一的设备id
        getEqpId = function() {

            var basicAddr = 1;
            var find = false;
            var length = linkno.length;
            for (var j = 0; j < length; j++) {
                var val = basicAddr + j;
                if (linkno[j] != val) {
                    linkno.splice(j, 0, val);
                    console.dir("insert :" + val + "result:" + linkno);
                    return val;
                    find = true;
                }
            }
            if (find == false) {
                var val = length + basicAddr
                linkno.splice(length, 1, val);
                console.dir("append :" + val + "result:" + linkno);
                return val;
            }


        }
        //删除一个数据，或是删除一个子数组。
        removeEqpId = function(val) {
            var length = linkno.length;
            console.dir("delete :" + val);
            for (var i = 0; i < length; i++) {
                if (linkno[i] == val) {
                    linkno.splice(i, 1);
                    console.dir("delete :" + val + " result:" + linkno);
                }
            }
        }
        return {
            get: getEqpId,
            remove: removeEqpId,
            append: appendEqpId

        }
    }());
    //对GPS进行特殊处理,GPS配置只有通道，没有规约属性配置
    // alert(gPageParam.processPage.procName);
    if (gPageParam.processPage.procName.indexOf("GPS") > -1) {

        var channelGirdA = initPropertyGrid("channelA", gPageParam.processPage.DriverType);
        var channelGirdB = initPropertyGrid("channelB", gPageParam.processPage.DriverType);

    } else {
        var channelGirdA = initPropertyGrid("channelA", gPageParam.processPage.ChannelType);
        var channelGirdB = initPropertyGrid("channelB", gPageParam.processPage.ChannelType);

        var driverGrid = initPropertyGrid("driver", gPageParam.processPage.DriverType);

    }



    setDlgTitle(gPageParam.processPage.procDesc);
    //提交界面数据到服务端
    $("#comit").off().on("click", function() {
        var dataa = $("#channelA").data("rowData");
        alert(JSON.stringify(dataa));

        var datab = $("#channelB").data("rowData");
        alert(JSON.stringify(datab));
		//  有规约的才提交规约
        if (gPageParam.processPage.procName.indexOf("GPS") >-1) 
				  {
        var datad = $("#driver").data("rowData");
        alert(JSON.stringify(datad));
				  }


    });


    //////////////////////////////////////////////////////
    // 关联选择，在这里不能直接使用返回的 channelGird 和 driverGrid ，
    // js执行顺序为异步，上面两个函数在调用的过程中，下面的代码已经备执行了
    // 停止使用：由于可能设计到多行同时编辑，修改单元格选择方式为'multiplecellsadvanced' ，
    //           所以该方法停止使用
    ////////////////////////////////////////////////////
    // $("#channelA,#channelB").off().on('rowselect', function(event) {
    //     var args = event.args;
    //     var row = args.rowindex;

    //     $("#driver").jqxGrid('selectrow', row);
    // });
    //======================================================
    //不能双向关联
    // $("#driver").on('rowselect', function(event) {
    //     var args = event.args;
    //     var row = args.rowindex;
    //     $("#channel").jqxGrid('selectrow', row);
    // });
    ////////////////////////////////////////////////////
    $('#machine_tab').jqxTabs({
        width: '99.5%',
        height: '313px',
        theme: theme,
        collapsible: true
    });



    //表格显示需要的数据  *Type 为显示dropdownlist需要的数据
    var gridProperty = {
        driver: {
            datafields: [],
            columns: [],
            emunList: {} // 通过 gridproperty.emunlist[field]=[] 方式添加，dropdownlist的值;
        },
        channelA: {
            datafields: [],
            columns: [],
            emunList: {} //gridproperty.emunlist[field]=[];
        },
        channelB: {
            datafields: [],
            columns: [],
            emunList: {} //gridproperty.emunlist[field]=[];
        }

    };
    initToolBar();
    ///////////////////////////////////////////////
    //  按钮初始化  增加-删除-同步A>B(提示，A机通道记录，将覆盖B机的通道记录)
    // 1 增加，同时在通道和驱动表格中都增加，前置机1和前置机2的通道配置，根据用户选择是否进行同步。
    // 2 前置机A 和前置机B 的同步，都是在客户端的同步，只有当点击提交的时候，才会将当前界面的配置写入数据库。
    // 3 点击添加按钮，提示增加记录条数，同时选择多条记录，可以批量删除。
    // 4 通道和规约中的记录保持同步增加，删除。选择删除项的时候，只支持在通道的表格中进行选择，然后删除。
    // 5 为了保证 连接号不重复，使用表格的uid
    ///////////////////////////////////////////////
    function initToolBar() {
        var toolAction = {
            add: function() {
                function addrow(dlg) {

                    var value = dlg.value;
                    var rowsAB = [],
                        rowsDriver = [];

                    function bindData(table, data, id) {
                        if (!table.data("rowData")) {
                            table.data("rowData", {});
                        }
                        var items = table.data("rowData");
                        var item = items[id];
                        //如果之前有对改时间的删除项，则修改为更新项。
                        if (item) {
                            item.handle = 'update';
                        } else {
                            //否则，新建插入项
                            item = {};
                            item.handle = 'insert';
                        }
                        item.val = data;

                        items[id] = item;
                        table.data("rowData", items);
                    }
                    for (var i = 0; i < value; i++) {
                        var linkno = LinkNo.get();
                        var rowab = {
                            "ProcName": gPageParam.processPage.procName,
                            "LinkNo": linkno,
                            "DblChannel": 0 //默认关闭双通道
                        };
                        var rowab1 = {
                            "ProcName": gPageParam.processPage.procName,
                            "LinkNo": linkno,
                            "DblChannel": 0 //默认关闭双通道
                        };
                        rowsAB.push(rowab);
                        bindData($("#channelA"), rowab1, linkno);
                        bindData($("#channelB"), rowab1, linkno);
                        //将通道和驱动分开处理就是因为通道中有dbchannel必填字段，且必须有一个初始值。
                        var rowd = {
                            "ProcName": gPageParam.processPage.procName,
                            "LinkNo": linkno
                        };
                        var rowd1 = {
                            "ProcName": gPageParam.processPage.procName,
                            "LinkNo": linkno
                        };
                        rowsDriver.push(rowd);
                        bindData($("#driver"), rowd1, linkno);

                    }
                    //执行下面的语句之后，rowsab会自动添加UID字段，现在还不知道是什么原因。
                    //uid字段是表格中的id,不能使用能表格同一个row

                    $("#channelA,#channelB").jqxGrid('addrow', null, rowsAB);


                    $("#driver").jqxGrid('addrow', null, rowsDriver);

                }
                $.config.prompt(addrow, "输入需要添加记录的条数：");



            },
            delete: function() {
                //这里只设计了 channelA的选择删除功能。对其他表格的选择删除是无效的。



                function deleterows(table) {

                    var cells = $('#channelA').jqxGrid('getselectedcells'); //||$('#channelB').jqxGrid('getselectedrowindex')||$('#driver').jqxGrid('getselectedrowindex');
                    // var cells = table.jqxGrid('getselectedcells');
                    var field = '';
                    if (cells[0]) {
                        field = cells[0].datafield;
                    }
                    var rowIDs = new Array();
                    for (var i = 0; i < cells.length; i++) {
                        var cell = cells[i];

                        var selectedrowindex = cell.rowindex;
                        // var selectedrowindex = table.jqxGrid('getselectedrowindex');
                        var rowscount = table.jqxGrid('getdatainformation').rowscount;
                        if (selectedrowindex >= 0 && selectedrowindex < rowscount && field == cell.datafield) {
                            var id = table.jqxGrid('getrowid', selectedrowindex);

                            rowIDs.push(id);
                            //获取当前选择的row，对row的数据操作的时候会用到
                            var row = table.jqxGrid('getrowdatabyid', id);
                            // alert(JSON.stringify(row));

                            if (!table.data("rowData")) {
                                table.data("rowData", {});
                            }
                            var items = table.data("rowData");
                            var item = items[row.LinkNo]

                            LinkNo.remove(row.LinkNo);

                            if (item) {
                                //更新的，标识为删除。
                                //添加的，直接删除
                                if (item.handle == 'update') {
                                    item.handle = 'delete';
                                } else {
                                    delete items[row.LinkNo];

                                }
                            } else {
                                //没有该项，添加，并标识为删除
                                item = {};
                                item.handle = 'delete';
                                items[row.LinkNo] = item;
                            }
                            table.data("rowData", items);
                            console.dir(row.LinkNo);
                        }
                    }
                    //批量删除
                    var commit = table.jqxGrid('deleterow', rowIDs);
                    //删除之后，由于选择项是按照rowid的，删除前面的row后面的会自动上移，还是处于选择状态。


                }
                deleterows($('#channelB'));
				
				if (gPageParam.processPage.procName.indexOf("GPS") <0) 
				  {
                            deleterows($('#driver'));
				 }
				 
                deleterows($('#channelA'));
                $('#channelA').jqxGrid('clearselection');

            },
            sync_ab: function() {
                //同步A-》B ，该操作会覆盖B的所有配置。
                var rows = $('#channelA').jqxGrid('getrows');
                var result = "";
                for (var i = 0; i < rows.length; i++) {

                    var row = rows[i];
                    $('#channelB').jqxGrid('updaterow', row.uid, row);


                    ////////alert(JSON.stringify(row));
                    //  result += row.firstname + " " + row.lastname + " " + row.productname + " " + row.date + " " + row.quantity + " " + row.price + "\n";
                }
            }
        };

        $("#toolbar").jqxButtonGroup({
            theme: theme,
            mode: 'default'
        }).on('buttonclick', function(event) {
            var clickedButton = event.args.button;
            toolAction[clickedButton[0].id]();
            //$("#eventsLog").text("Clicked: " + clickedButton[0].id);
        });


    }

    /////////////////////////////////////////////////////////////////////
    //加载配置文件，并形成界面
    // driverOrchannel  通道或是驱动
    // perpertyTye  具体通道或是驱动的类型
    /////////////////////////////////////////////////////////////////////
    function initPropertyGrid(driverOrchannel, propertyType) {

        var source = {
            datatype: "xml",
            datafields: [{
                name: 'Desc',
                map: 'm\\:properties>d\\:Desc'
            }, {
                name: 'Field',
                map: 'm\\:properties>d\\:Field'
            }, {
                name: 'DefaultValue',
                map: 'm\\:properties>d\\:DefaultValue'
            }, {
                name: 'DataType',
                map: 'm\\:properties>d\\:DataType'
            }, {
                name: 'Enum',
                map: 'm\\:properties>d\\:EnumData' //在低版本中，xml的项必须存在，且不能为空，高版本中可以不存在，且能为空，所以在没有枚举量的xml项中补填N作为占位
            }],
            root: "content",
            // record : "content",
            id: 'm\\:properties>d\\:Field',
            url: "table_xml/" + propertyType + ".xml"
        };
        //加载配置文件
        var dataAdapter = new $.jqx.dataAdapter(source, {
            autoBind: true,
            loadComplete: function() {
                // get data records.
                var records = dataAdapter.records;
                var length = records.length;
                for (var i = 0; i < length; i++) {
                    var record = records[i];
                    var fields = {};
                    fields["name"] = record.Field;
                    if (records.Field == "LinkNo")
                        fields["type"] = "number";

                    gridProperty[driverOrchannel].datafields.push(fields);

                    var column = {};
                    column["datafield"] = record.Field;
                    column["text"] = record.Desc;
                    if ((record.Field == 'ProcName') || (record.Field == 'LinkNo')) {
                        column["editable"] = false;
                    }

                    //根据 配置项的多少决定是否设置宽度
                    var width = $("#proc_property").width();
                    if ((length * 100) > width)
                        column["width"] = 100;
                    if (record.DataType.indexOf("Bool") > -1) { //设置checkbbox为bool编辑
                        column["columntype"] = 'checkbox';
                    } else {

                        if (record.DataType.indexOf("Enum") > -1) //直接判断== 也可以，为了防止字符串中的空格
                        {

                            column["columntype"] = 'dropdownlist';
                            try {
                                gridProperty[driverOrchannel].emunList[record.Field] = [];
                                // eval('(' + record.Enum + ')')     字符串转换json的另一种方法                            
                                var enumval = jQuery.parseJSON(record.Enum); //将枚举类型的json字符串转换为json对象，

                                // $(enumval).each(function(feild,text){
                                $.each(enumval, function(value, text) { //遍历json对象，形成dropdownlist需要的source对象
                                    var item = {};
                                    item["value"] = value;
                                    item["text"] = text;

                                    //alert(text+"==="+value);

                                    gridProperty[driverOrchannel].emunList[record.Field].push(item);


                                });
                            } catch (e) {
                                console.warn(record.Field + " comes error!");

                            }
                            column["createeditor"] = function(row, cellvalue, editor, celltext, cellwidth, cellheight) {
                                // assign a new data source to the dropdownlist.
                                // console.dir(this.datafield +"==" + cellvalue);  
                                editor.jqxDropDownList({
                                    source: gridProperty[driverOrchannel].emunList[this.datafield],
                                    placeHolder: "",
                                    autoDropDownHeight: true,
                                    displayMember: "text",
                                    valueMember: "value",
                                    theme: theme
                                });

                            };

                            column["initEditor"] = function(row, cellvalue, editor, celltext, width, height) {
                                // set the editor's current value. The callback is called each time the editor is displayed.
                                editor.jqxDropDownList({
                                    width: width,
                                    height: height
                                });

                                editor.val(cellvalue);
                            };


                            column["getEditorValue"] = function(row, cellvalue, editor) {
                                // return the editor's value.

                                return editor.val();
                            };

                            column["cellvaluechanging"] = function(row, column, columntype, oldvalue, newvalue) {
                                // return the old value, if the new value is empty.
                                if (newvalue == "") return oldvalue;
                            };
                        }

                        column["cellbeginedit"] = function(row, datafield, columntype) {
                            //获取row对应的datafield的flag的ckeckbox，如果是1，返回true，如果是0，返回false
                            //如果量测启用，前面的所有项才可编辑
                            //这里只有遥测会有这样的配置约束，所以在这里直接填写了遥测dom的div对应的id。在这里取dom的owner的id。不太好弄
                            //波动 Fluc     --对应单元格返回false

                            //双通道 开启标识。
                            var editableFlag = true;

                            if (datafield.indexOf("2") > -1) {

                                editableFlag = $("#" + driverOrchannel).jqxGrid('getcellvalue', row, "DblChannel");

                            }

                            return editableFlag;

                        } //end cellbeginedit
                        //checkbox 相关的单元格，如果checkbox没有备选中，不允许编辑
                        column["cellsrenderer"] = function(row, datafield, value, defaultHtml, columnproperties) {
                            //根据 column->feild column 判断当前列。
                            var editableFlag = true;
                            // if ((datafield == "PortName2") || (datafield == "Band2") || (datafield == "Parity2") || (datafield == "DataBits2") || (datafield == "StopBits2")) {
                            //设置双通道的可编辑设置
                            if (datafield.indexOf("2") > -1) {
                                // alert(datafield);
                                editableFlag = $("#" + driverOrchannel).jqxGrid('getcellvalue', row, "DblChannel");

                            }
                            //设置枚举变量的显示值
                            if (columnproperties.columntype == "dropdownlist") {

                                $.each(gridProperty[driverOrchannel].emunList[datafield], function(n, val) {
                                    if (val.value == value) {

                                        defaultHtml = "<div  style='text-align: left; overflow: hidden; padding-bottom: 2px; margin-top: 4px; margin-right: 2px; margin-left: 4px; text-overflow: ellipsis;'>" + val.text + "</div>";
                                    }
                                });
                            }

                            if (editableFlag == false) {
                                var element = $(defaultHtml);
                                element.css('color', '#131313');
                                return element[0].outerHTML;
                            }

                            return defaultHtml;

                        } //end cellsrenderer
                    }
                    gridProperty[driverOrchannel].columns.push(column);
                }

                //================== 表格初始话数据加载完成了之后才初始化 tab，然后在tab的init中初始化表格
                return crateGird(driverOrchannel, propertyType);
            }
        });
        //初始化 右键菜单，单个选择单元格的右键复制，多个选择，只赋值第一个单元格的数据
        //多个选择单元格的选择粘贴功能。
        //
        function initMeasureContextMenu() {
            // create context menu
            var contextMenu = $("#measure_menu").jqxMenu({
                width: 100,
                height: 30,
                theme: theme,
                autoOpenPopup: false,
                mode: 'popup'
            }).off().on('itemclick', function(event) {
                var target = $(event.target);
                //通过item-value，路由处理菜单点击事件
                switch (target.attr("item-value")) {

                    case "prompt":
                        {

                            var table = $(this).data("table");

                            function setval(dlg) {
                                //  alert("setval"+dlg.value);
                                //获取当前操作的 grid

                                var cells = table.jqxGrid('getselectedcells');
                                var field = '';
                                if (cells[0]) {
                                    //由于设置了 进程名称和数据类型隐藏属性，所以在获取当前选择列的时候会获取到该列。
                                    //通过查看js调试信息，获取一下信息代替直接的datafield。
                                    field = cells[0].owner._clickedcolumn || cells[0].datafield;
                                    //数据全局ID不允许编辑，值能够添加，删除
                                    if (field == 'LinkNo') {

                                        return;
                                    }

                                } else {
                                    $.config.alertDlg("请选择需要批量粘贴的单元格！")
                                }
                                var rowIDs = new Array();
                                for (var i = 0; i < cells.length; i++) {
                                    var cell = cells[i];

                                    var selectedrowindex = cell.rowindex;
                                    // var selectedrowindex = table.jqxGrid('getselectedrowindex');
                                    // var rowscount = table.jqxGrid('getdatainformation').rowscount;//&& field == cell.datafield
                                    var rowscount = table.jqxGrid('getrows').length;
                                    //if (selectedrowindex >= 0 && selectedrowindex < rowscount) {
                                    var id = table.jqxGrid('getrowid', selectedrowindex);
                                    var val = dlg.value;
                                    // var row= table.jqxGrid('getrowdata', selectedrowindex);
                                    // row[field]= val.toUpperCase();
                                    // table.jqxGrid('updaterow', id,row);

                                    //所有字符全部转换为大写，避免输入的时候大小写的错误
                                    table.jqxGrid('setcellvalue', id, field, val.toUpperCase());

                                    // }
                                }
                                table.jqxGrid('refreshdata');

                            };

                            $.config.prompt(setval, "输入数值：");


                        }
                };

            });

            return contextMenu;
        }
        var measureContextMenu = initMeasureContextMenu();
        //////////////////////////////////////////////////////////////////
        // 通过配置文件加载的数据项，形成数据表格框架，并加根据 propertyType加载表格数据
        //
        //////////////////////////////////////////////////////////////////
        function crateGird(driverOrchannel, propertyType) {

            var source = {
                datatype: "csv",
                datafields: gridProperty[driverOrchannel].datafields,
                id: "LinkNo",
                url: 'defaultData/DriverData/' + propertyType + '.csv'
            };

            var dataAdapter = new $.jqx.dataAdapter(source, {
                async: false,
                loadError: function(xhr, status, error) {
                    // alert('Error loading "' + source.url + '" : ' + error);
                }
            });

            var table = $("#" + driverOrchannel).jqxGrid({
                width: '99.5%',
                height: '273',
                theme: theme,
                columnsresize: true, //设置可调整columns大小
                editable: true,
                altrows: true,
                source: dataAdapter,
                selectionmode: 'multiplecellsadvanced', //设置选择方式
                columns: gridProperty[driverOrchannel].columns
            }).on('cellvaluechanged', function(event) {

                var field = args.datafield;
                var rowindex = args.rowindex;
                var value = args.newvalue;
                if (!value)
                    return;

                var row = table.jqxGrid('getrowdata', rowindex);
                var oldvalue = args.oldvalue;
                //设置变化值到缓存中
                if (!$(this).data("rowData"))
                    $(this).data("rowData", {});
                var rowData = $(this).data("rowData");
                var item = rowData[row.LinkNo];
                if (item) {
                    //更新的，直接更新数据，更新对应字段的数据。
                    //添加的 ，不更新操作，直接更新数据。
                    //删除的，提示删除一条已经备删除的记录。
                    if (item.handle == 'delete') {
                        console.dir("错误，更新一条需要删除的记录");
                    } else {
                        item.val[field] = value;
                    }
                } else {
                    //没有就创建一条更新的数据
                    item = {};
                    item.handle = 'update';
                    item.val = {};
                    item.val[field] = value;
                }

                rowData[row.LinkNo] = item; //更新到rowdata

                $(this).data("rowData", rowData);


                // console.dir(column + '==' + row + "===" + value + $(this).attr('id'));

            }).on('cellclick', function(event) {
                if (event.args.rightclick) {
                    var value = event.args.value;
                    var column = event.args.column;
                    var rowindex = event.args.rowindex;
                    var columnindex = event.args.columnindex;
                    //不允许编辑的列，没有菜单项
                    if (column.editable == false)
                        return;

                    //如果没有选择单元格，以当前鼠标点击的单元格作为复制源
                    measureContextMenu.data('clipBord_tmp', value);
                    //目前设计，只针对单个源-》多个目标的复制粘贴，如果是多个源到多个目标


                    var scrollTop = $(window).scrollTop();
                    var scrollLeft = $(window).scrollLeft();
                    measureContextMenu.jqxMenu('open', parseInt(event.args.originalEvent.clientX) + 5 + scrollLeft, parseInt(event.args.originalEvent.clientY) + 5 + scrollTop);
                    //将当前tab 放入菜单中,在菜单事件中，通过table变量，操作对应的grid
                    measureContextMenu.data("table", $(this));

                    return false;
                }
            });

            console.dir("创建数据配置表成功！");
            return table;
        }

    }
});